package com.dabai.simpleconnection_udp.utils;

import android.text.TextUtils;
import android.util.Patterns;


import java.util.HashMap;
import java.util.Random;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


/**
 * 关于 字符串的 快捷操作
 */
public class StringUtils {

    /**
     * 获取字符串的长度，中文占一个字符,英文数字占半个字符
     *
     * @param value  指定的字符串
     * @return 字符串的长度
     */
    public static int length(String value) {
        return value.toCharArray().length;
    }


    /**
     * 包含忽略大小写
     *
     * @param text1 text1
     * @param text2 text2
     * @return boolean
     */
    public static boolean containsIgnoreCase(String text1,String text2) {
        return text1.toUpperCase().contains(text2.toUpperCase());
    }

    /**
     * 全部为空
     *
     * @param text 文本
     * @return boolean
     */
    public static boolean allEmpty(String... text) {
        for (String tmp : text) {
            if (!isEmpty(tmp)) {
                return false;
            }
        }
        return true;
    }
    /**
     * 包含空
     *
     * @param text 文本
     * @return boolean
     */
    public static boolean containsEmpty(String... text) {
        for (String tmp : text) {
            if (isEmpty(tmp)) {
                return true;
            }
        }
        return false;
    }


    /**
     * 输入行
     *
     * @param objects 对象
     * @return {@link String}
     */
    public static String inputLine(Object... objects) {
        StringBuilder stringBuilder = new StringBuilder();
        for (Object object : objects) {
            if (object==null){
                continue;
            }
            stringBuilder.append(object);
            stringBuilder.append("\n");
        }
        return stringBuilder.substring(0,stringBuilder.length()-1);
    }


    /**
     * 批量替换
     *
     * @param content 内容
     * @param rule    规则
     * @return {@link String}
     */
    public static String batchReplacement(String content, HashMap<String,String> rule){
        for (String key : rule.keySet()){
            String replace =  rule.get(key);
            if (StringUtils.isEmpty(replace)){
                continue;
            }
            content = content.replaceAll(key,replace);
        }
        return content;
    }



    /**
     * 开始 其中一个 就返回真
     *
     * @param content  内容
     * @param contains 包含
     * @return boolean
     */
    public static boolean startWith(String content, String... contains) {
        for (String tmp : contains) {
            if (content.startsWith(tmp)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 结尾 其中一个
     *
     * @param content  内容
     * @param contains 包含
     * @return boolean
     */
    public static boolean endWith(String content, String... contains) {
        for (String tmp : contains) {
            if (content.endsWith(tmp)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 包含其中一个
     *
     * @param content  内容
     * @param contains 包含
     * @return boolean
     */
    public static boolean contains(String content, String... contains) {
        for (String tmp : contains) {
            if (content.contains(tmp)) {
                return true;
            }
        }
        return false;
    }

    public static int getChineseNum(String content) {
        int count = 0;
        char[] chars = content.toCharArray();
        for (char c : chars) {
            if (StringUtils.isContainChinese(c + "")) {
                count++;
            }
        }
        return count;
    }

    public static int getAnEndNum(String content) {
        int count = 0;
        char[] chars = content.toCharArray();
        for (char c : chars) {
            if (c == '.' || c == '。') {
                count++;
            }
        }
        return count;
    }

    public static int getEnglishNum(String content) {
        int count = 0;
        char[] chars = content.toCharArray();
        for (char c : chars) {

            if ((c >= 97 && c <= 122) || (c >= 65 && c <= 90)) {
                count++;
            }
        }
        return count;
    }

    public static int getNumberNum(String content) {
        int count = 0;
        char[] chars = content.toCharArray();
        for (char c : chars) {

            if (c >= 48 && c <= 57) {
                count++;
            }
        }
        return count;
    }



    /**
     * 出现的数量
     * 获取指定字符串出现的次数
     *
     * @param srcText  源字符串
     * @param findText 要查找的字符串
     * @return int
     */
    public static int getAppearNumber(String srcText, String findText) {
        int count = 0;
        Pattern p = Pattern.compile(findText);
        Matcher m = p.matcher(srcText);
        while (m.find()) {
            count++;
        }
        return count;
    }

    /**
     * 判断给定字符串是否空白串。 空白串是指由空格、制表符、回车符、换行符组成的字符串 若输入字符串为null或空字符串，返回true
     * ViewRoot
     *
     * @param input 输入
     * @return boolean
     */
    public static boolean isEmpty(String input) {
        if (input == null || "".equals(input))
            return true;

        for (int i = 0; i < input.length(); i++) {
            char c = input.charAt(i);
            if (c != ' ' && c != '\t' && c != '\r' && c != '\n') {
                return false;
            }
        }
        return true;
    }

    /**
     * 判断是否包含有特殊符号
     *
     * @param str the str
     * @return boolean boolean
     */
    public static boolean containSpecialSymbols(String str) {
        // 不包含特殊字符
        return str.replaceAll("[\u4e00-\u9fa5]*[a-z]*[A-Z]*\\d*-*_*\\s*", "").length() != 0;
    }



    /**
     * 检查 字符串是否全部为 数字
     */
    public static boolean allIsDigital(String str) {
        for (int i = 0; i < str.length(); i++) {
            if (!Character.isDigit(str.charAt(i))) {
                return false;
            }
        }
        return true;
    }


    /**
     * 检查 字符串是否全部为 汉字
     */
    public static boolean allIsChinese(String str) {
        for (char c : str.toCharArray()){
            if (!(c >= 19968 && c <= 40869)){
                return false;
            }
        }
        return true;
    }


    /**
     * 得到中文字符数量
     *
     * @param content 内容
     * @return int
     */
    public static int getChineseCharactersNumber(String content) {
        int count = 0;
        char[] chars = content.toCharArray();
        for (char c : chars) {
            if (StringUtils.isContainChinese(c + "")) {
                count++;
            }
        }
        return count;
    }

    /**
     * 得到字符串中 句子数量
     *
     * @param content 内容
     * @return int
     */
    public static int getSentencesNumber(String content) {
        int count = 0;
        char[] chars = content.toCharArray();
        for (char c : chars) {
            if (c == '.' || c == '。') {
                count++;
            }
        }
        return count;
    }

    /**
     * 得到字母数量
     *
     * @param content 内容
     * @return int
     */
    public static int getLettersNumber(String content) {
        int count = 0;
        char[] chars = content.toCharArray();
        for (char c : chars) {

            if ((c >= 97 && c <= 122) || (c >= 65 && c <= 90)) {
                count++;
            }
        }
        return count;
    }

    /**
     * 得到数字数量
     *
     * @param content 内容
     * @return int
     */
    public static int getDigitalNumber(String content) {
        int count = 0;
        char[] chars = content.toCharArray();
        for (char c : chars) {

            if (c >= 48 && c <= 57) {
                count++;
            }
        }
        return count;
    }


    /**
     * 获取随机颜色值
     * <p>
     * 比如 #FFFFFF
     */
    public static String getRandColorCode() {
        String r, g, b;
        Random random = new Random();
        r = Integer.toHexString(random.nextInt(256)).toUpperCase();
        g = Integer.toHexString(random.nextInt(256)).toUpperCase();
        b = Integer.toHexString(random.nextInt(256)).toUpperCase();

        r = r.length() == 1 ? "0" + r : r;
        g = g.length() == 1 ? "0" + g : g;
        b = b.length() == 1 ? "0" + b : b;

        return "#" + r + g + b;
    }

    /**
     * /检查字符串包含中文
     */
    public static boolean isContainChinese(String str) {
        Pattern p = Pattern.compile("[\u4e00-\u9fa5]");
        Matcher m = p.matcher(str);
        return m.find();
    }

    /**
     * 产生随机长度的字符串
     * 字符合集 自定义
     */
    public static String getRandomString(int length) {
        String str = "abcdefghijklmnopqrstuvwxyz0123456789";
        Random random = new Random();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < length; i++) {
            int number = random.nextInt(36);
            sb.append(str.charAt(number));
        }
        return sb.toString();
    }




    /***
     * 检查是否若密码
     ***/
    public static boolean isWeakPassword(String v) {
        if (v.length() < 6) return true;
        return v.matches("^\\d*?$|^[a-z]*?$|^[A-Z]*?$");
    }


    /**
     * 正则表达式：验证手机号
     */
    private static final String REGEX_PHONE_NUMBER = "^(0(10|2\\d|[3-9]\\d\\d)[- ]{0,3}\\d{7,8}|0?1[3584]\\d{9})$";

    /**
     * 正则表达式：验证邮箱
     */
    private static final String REGEX_EMAIL = "^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";


    /**
     * 中国手机号码检查
     * @param mobile 移动
     *
     * @return boolean
     */
    public static boolean isPhoneNumber(String mobile) {
        /*
        移动：134、135、136、137、138、139、150、151、157(TD)、158、159、187、188
        联通：130、131、132、152、155、156、185、186
        电信：133、153、180、189、（1349卫通）
        总结起来就是第一位必定为1，第二位必定为3或5或8，其他位置的可以为0-9
        */
        String telRegex = "[1][3578]\\d{9}";//"[1]"代表第1位为数字1，"[358]"代表第二位可以为3、5、8中的一个，"\\d{9}"代表后面是可以是0～9的数字，有9位。
        if (TextUtils.isEmpty(mobile)) return false;
        else return mobile.matches(telRegex);
    }

    /**
     * 校验手机号
     *
     * @param mobile 移动
     * @return 校验通过返回true，否则返回false
     */
    public static boolean isMobile(String mobile) {
        return Pattern.matches(REGEX_PHONE_NUMBER, mobile);
    }

    /**
     * 是电子邮件
     * 校验邮箱
     *
     * @param email 电子邮件
     * @return 校验通过返回true，否则返回false
     */
    public static boolean isEmail(String email) {
        return Pattern.matches(REGEX_EMAIL, email);
    }

}
